home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Contributed / SpriteWorld / SpriteWorld Files / BlitPixie / Sources / BlitPixieRLECollision.c < prev    next >
Encoding:
Text File  |  2000-10-06  |  4.7 KB  |  204 lines  |  [TEXT/CWIE]
  1. ///--------------------------------------------------------------------------------------
  2. //    BlitPixieRLECollision
  3. //
  4. //    Written by Anders F Björklund <afb@algonet.se>
  5. //    © 1998-99 afb.
  6. ///--------------------------------------------------------------------------------------
  7.  
  8. #ifndef __BLITPIXIE__
  9. #include "BlitPixieHeader.h"
  10. #endif
  11.  
  12. #ifndef GENERATINGASM // do not include for asm file generation
  13.  
  14. #ifndef MIN
  15. #define MIN(a,b)                    (a < b ? a : b )
  16. #endif
  17. #ifndef MAX
  18. #define MAX(a,b)                    (a > b ? a : b )
  19. #endif
  20.  
  21. #define ALIGN_PTR(p)                ( -((long) p) & 3)
  22.  
  23. ///--------------------------------------------------------------------------------------
  24. //        BlitPixieRLECollision - checks two RLE sprites for solid span overlap
  25. ///--------------------------------------------------------------------------------------
  26.  
  27. Boolean BlitPixieRLECollision(
  28.     unsigned char *srcTokens,
  29.     unsigned char *dstTokens,
  30.     Rect *srcRect,
  31.     Rect *dstRect)
  32. {
  33.     unsigned long    token1,op1,count1;
  34.     unsigned long    token2,op2,count2;
  35.     unsigned  char    *nextRow1,*nextRow2;
  36.     long            x,width;
  37.     long            y,height;
  38.     long            x1,x2;
  39.     int                solid1,solid2;
  40.     
  41.         // advance source to first row
  42.     for ( y = 0; y < srcRect->top; y++ )
  43.     { 
  44.         token1 = *((TokenDataType *) srcTokens);
  45.         srcTokens += sizeof(TokenDataType);
  46.  
  47.         op1 = token1 >> kTokenShift;
  48.         count1 = token1 & kCountMask;
  49.  
  50.         if ( op1 == kLineStartToken )
  51.             srcTokens += count1;    
  52.         else if ( op1 == kEndShapeToken )
  53.             return false;
  54.         else
  55.             BLITPIXIE_DEBUGGER("BlitPixieRLECollision: Unexpected token");
  56.     }
  57.     
  58.         // advance dest to first row
  59.     for ( y = 0; y < dstRect->top; y++ )
  60.     { 
  61.         token2 = *((TokenDataType *) dstTokens);
  62.         dstTokens += sizeof(TokenDataType);
  63.  
  64.         op2 = token2 >> kTokenShift;
  65.         count2 = token2 & kCountMask;
  66.  
  67.         if ( op2 == kLineStartToken )
  68.             dstTokens += count2;    
  69.         else if ( op2 == kEndShapeToken )
  70.             return false;
  71.         else
  72.             BLITPIXIE_DEBUGGER("BlitPixieRLECollision: Unexpected token");
  73.     }    
  74.     
  75.     height = srcRect->bottom - srcRect->top;    // == dstRect->bottom - dstRect->top
  76.     width = srcRect->right - srcRect->left;        // == dstRect->right - dstRect->left
  77.     
  78.         // check the intersecting rows for span overlap
  79.     for ( y = 0; y < height; y++ )
  80.     {
  81.         token1 = *((TokenDataType *) srcTokens);
  82.         srcTokens += sizeof(TokenDataType);
  83.         
  84.         op1 = token1 >> kTokenShift;
  85.         count1 = token1 & kCountMask;
  86.  
  87.         token2 = *((TokenDataType *) dstTokens);
  88.         dstTokens += sizeof(TokenDataType);
  89.         
  90.         op2 = token2 >> kTokenShift;
  91.         count2 = token2 & kCountMask;
  92.  
  93.         if ( op1 == kEndShapeToken || op2 == kEndShapeToken )
  94.             return false;
  95.  
  96.         if ( op1 != kLineStartToken || op2 != kLineStartToken )
  97.             BLITPIXIE_DEBUGGER("BlitPixieRLECollision: Unexpected token");
  98.  
  99.         nextRow1 = srcTokens + count1;
  100.         nextRow2 = dstTokens + count2;
  101.  
  102.         op1 = -1;
  103.         op2 = -1;
  104.         solid1 = false;
  105.         solid2 = false;
  106.         x1 = - srcRect->left;
  107.         x2 = - dstRect->left;
  108.         
  109.         for ( x = x1 < x2 ? x1 : x2 ; x < width; x = x1 < x2 ? x1 : x2  )
  110.         {
  111.             if ( x1 < x2 )
  112.             {
  113.                 token1 = *((TokenDataType *) srcTokens);
  114.                 srcTokens += sizeof(TokenDataType);
  115.         
  116.                 op1 = token1 >> kTokenShift;
  117.                 count1 = token1 & kCountMask;
  118.             
  119.                 switch ( op1 )
  120.                 {
  121.                     case kDrawPixelsToken:
  122.                         solid1 = true;
  123.                         x1 += count1;
  124.                         srcTokens += count1;
  125.                         srcTokens += ALIGN_PTR(srcTokens);
  126.                         break;
  127.                     case kSkipPixelsToken:
  128.                         solid1 = false;
  129.                         x1 += count1;
  130.                         break;
  131.                 #if BLITPIXIE_USE_DRAW_SPANS
  132.                     case kSingleColorToken:
  133.                         solid1 = true;
  134.                         x1 += count1;
  135.                         srcTokens += 4;
  136.                         break;
  137.                 #endif
  138.                     case kLineStartToken:
  139.                         solid1 = false;
  140.                         x1 = width;
  141.                         break;
  142.                     case kEndShapeToken:
  143.                         return false;
  144.                     default:
  145.                         BLITPIXIE_DEBUGGER("BlitPixieRLECollision: Unknown token");
  146.                 }
  147.                 
  148.             }
  149.             else // if ( x1 >= x2 )
  150.             {
  151.                 token2 = *((TokenDataType *) dstTokens);
  152.                 dstTokens += sizeof(TokenDataType);
  153.         
  154.                 op2 = token2 >> kTokenShift;
  155.                 count2 = token2 & kCountMask;
  156.             
  157.                 switch ( op2 )
  158.                 {
  159.                     case kDrawPixelsToken:
  160.                         solid2 = true;
  161.                         x2 += count2;
  162.                         dstTokens += count2;
  163.                         dstTokens += ALIGN_PTR(dstTokens);
  164.                         break;
  165.                     case kSkipPixelsToken:
  166.                         solid2 = false;
  167.                         x2 += count2;
  168.                         break;
  169.                 #if BLITPIXIE_USE_DRAW_SPANS
  170.                     case kSingleColorToken:
  171.                         solid2 = true;
  172.                         x2 += count2;
  173.                         dstTokens += 4;
  174.                         break;
  175.                 #endif
  176.                     case kLineStartToken:
  177.                         solid2 = false;
  178.                         x2 = width;
  179.                         break;
  180.                     case kEndShapeToken:
  181.                         return false;
  182.                     default:
  183.                         BLITPIXIE_DEBUGGER("BlitPixieRLECollision: Unknown token");
  184.                 }
  185.             }
  186.             
  187.             if ( solid1 && solid2 )
  188.                 return true;
  189.  
  190.             if ( op1 == kLineStartToken || op2 == kLineStartToken )
  191.                 break;
  192.         }
  193.         
  194.         srcTokens = nextRow1;
  195.         dstTokens = nextRow2;
  196.     }
  197.  
  198.     return false;
  199. }
  200.  
  201. #endif //GENERATINGASM
  202.  
  203.  
  204.